package com.smart.translator.util;

import android.content.Context;
import android.util.Log;

/**
 * VAD管理器 - 统一管理VAD检测功能
 * 提供全局VAD类型设置和检测功能
 */
public class VadManager {
    private static final String TAG = "VadManager";
    
    // 单例实例
    private static volatile VadManager instance;
    
    // VAD检测器
    private VadDetector vadDetector;
    
    // 上下文
    private Context context;
    
    // VAD检测回调接口
    public interface VadCallback {
        void onSpeechStart();
        void onSpeechEnd();
        void onVoiceActivity(boolean isSpeech);
    }
    
    private VadCallback callback;
    
    // VAD状态跟踪
    private boolean isSpeechDetected = false;
    private long speechStartTime = 0;
    private long speechEndTime = 0;
    
    // 私有构造函数
    private VadManager(Context context) {
        this.context = context.getApplicationContext();
        Log.d(TAG, "VadManager初始化");
    }
    
    /**
     * 获取单例实例
     */
    public static VadManager getInstance(Context context) {
        if (instance == null) {
            synchronized (VadManager.class) {
                if (instance == null) {
                    instance = new VadManager(context);
                }
            }
        }
        return instance;
    }
    
    /**
     * 初始化VAD管理器
     */
    public void initialize() {
        Log.d(TAG, "初始化VAD管理器，当前VAD类型: " + VadDetector.getCurrentVadType().getDisplayName());
        
        if (vadDetector == null) {
            vadDetector = new VadDetector(context);
        }
        
        // 使用默认参数初始化VAD检测器
        vadDetector.initialize(16000, 1024); // 16kHz采样率，1024帧大小（64ms），匹配Silero VAD要求
        Log.d(TAG, "VAD管理器初始化完成");
    }
    
    /**
     * 设置VAD类型
     */
    public void setVadType(VadDetector.VadType vadType) {
        Log.d(TAG, "设置VAD类型: " + vadType.getDisplayName());
        VadDetector.setVadType(vadType);
        
        // 如果VAD检测器已存在，切换类型
        if (vadDetector != null) {
            vadDetector.switchVadType(vadType);
        }
    }
    
    /**
     * 获取当前VAD类型
     */
    public VadDetector.VadType getCurrentVadType() {
        return VadDetector.getCurrentVadType();
    }
    
    /**
     * 设置VAD回调
     */
    public void setCallback(VadCallback callback) {
        this.callback = callback;
        Log.d(TAG, "VAD回调已设置");
    }
    
    /**
     * 处理音频数据
     * @param audioData 音频数据（PCM格式）
     * @return 是否检测到语音活动
     */
    public boolean processAudio(byte[] audioData) {
        if (vadDetector == null) {
            Log.w(TAG, "VAD检测器未初始化，尝试初始化");
            initialize();
            if (vadDetector == null) {
                return false;
            }
        }
        
        try {
            // 使用VAD检测器检测语音
            boolean isSpeech = vadDetector.processAudio(audioData);
            
            // 状态变化检测
            boolean previousSpeechState = isSpeechDetected;
            isSpeechDetected = isSpeech;
            
            // 通知回调
            if (callback != null) {
                callback.onVoiceActivity(isSpeech);
                
                // 检测语音开始
                if (isSpeech && !previousSpeechState) {
                    speechStartTime = System.currentTimeMillis();
                    callback.onSpeechStart();
                    Log.d(TAG, "🎤 VAD检测到语音开始");
                }
                
                // 检测语音结束
                if (!isSpeech && previousSpeechState) {
                    speechEndTime = System.currentTimeMillis();
                    callback.onSpeechEnd();
                    long duration = speechEndTime - speechStartTime;
                    Log.d(TAG, "🔇 VAD检测到语音结束，持续时间: " + duration + "ms");
                }
            }
            
            return isSpeech;
            
        } catch (Exception e) {
            Log.e(TAG, "VAD处理音频数据失败", e);
            return false;
        }
    }
    
    /**
     * 处理音频数据（short数组格式）
     * @param pcmData PCM音频数据
     * @return 是否检测到语音活动
     */
    public boolean processAudio(short[] pcmData) {
        if (vadDetector == null) {
            Log.w(TAG, "VAD检测器未初始化，尝试初始化");
            initialize();
            if (vadDetector == null) {
                return false;
            }
        }
        
        try {
            // 使用VAD检测器检测语音
            boolean isSpeech = vadDetector.processAudio(pcmData);
            
            // 状态变化检测
            boolean previousSpeechState = isSpeechDetected;
            isSpeechDetected = isSpeech;
            
            // 通知回调
            if (callback != null) {
                callback.onVoiceActivity(isSpeech);
                
                // 检测语音开始
                if (isSpeech && !previousSpeechState) {
                    speechStartTime = System.currentTimeMillis();
                    callback.onSpeechStart();
                    Log.d(TAG, "🎤 VAD检测到语音开始");
                }
                
                // 检测语音结束
                if (!isSpeech && previousSpeechState) {
                    speechEndTime = System.currentTimeMillis();
                    callback.onSpeechEnd();
                    long duration = speechEndTime - speechStartTime;
                    Log.d(TAG, "🔇 VAD检测到语音结束，持续时间: " + duration + "ms");
                }
            }
            
            return isSpeech;
            
        } catch (Exception e) {
            Log.e(TAG, "VAD处理PCM数据失败", e);
            return false;
        }
    }
    
    /**
     * 处理音频数据（float数组格式）
     * @param floatData 音频数据（float格式，-1.0到1.0范围）
     * @return 是否检测到语音活动
     */
    public boolean processAudio(float[] floatData) {
        if (vadDetector == null) {
            Log.w(TAG, "VAD检测器未初始化，尝试初始化");
            initialize();
            if (vadDetector == null) {
                return false;
            }
        }
        
        try {
            // 将float数组转换为short数组进行处理
            short[] pcmData = new short[floatData.length];
            for (int i = 0; i < floatData.length; i++) {
                // 将-1.0到1.0的float值转换为-32768到32767的short值
                pcmData[i] = (short) (floatData[i] * 32767.0f);
            }
            
            // 使用VAD检测器检测语音
            boolean isSpeech = vadDetector.processAudio(pcmData);
            
            // 状态变化检测
            boolean previousSpeechState = isSpeechDetected;
            isSpeechDetected = isSpeech;
            
            // 通知回调
            if (callback != null) {
                callback.onVoiceActivity(isSpeech);
                
                // 检测语音开始
                if (isSpeech && !previousSpeechState) {
                    speechStartTime = System.currentTimeMillis();
                    callback.onSpeechStart();
                    Log.d(TAG, "🎤 VAD检测到语音开始");
                }
                
                // 检测语音结束
                if (!isSpeech && previousSpeechState) {
                    speechEndTime = System.currentTimeMillis();
                    callback.onSpeechEnd();
                    long duration = speechEndTime - speechStartTime;
                    Log.d(TAG, "🔇 VAD检测到语音结束，持续时间: " + duration + "ms");
                }
            }
            
            return isSpeech;
            
        } catch (Exception e) {
            Log.e(TAG, "VAD处理float数据失败", e);
            return false;
        }
    }
    
    /**
     * 重置VAD管理器
     */
    public void reset() {
        Log.d(TAG, "重置VAD管理器");
        
        if (vadDetector != null) {
            vadDetector.release();
            vadDetector = null;
        }
        
        // 重置状态
        isSpeechDetected = false;
        speechStartTime = 0;
        speechEndTime = 0;
        
        // 重新初始化
        initialize();
    }
    
    /**
     * 释放资源
     */
    public void release() {
        Log.d(TAG, "释放VAD管理器资源");
        
        if (vadDetector != null) {
            vadDetector.release();
            vadDetector = null;
        }
        
        // 重置状态
        isSpeechDetected = false;
        speechStartTime = 0;
        speechEndTime = 0;
        callback = null;
    }
    
    /**
     * 检查是否已初始化
     */
    public boolean isInitialized() {
        return vadDetector != null && vadDetector.isInitialized();
    }
    
    /**
     * 获取当前语音检测状态
     */
    public boolean isSpeechDetected() {
        return isSpeechDetected;
    }
    
    /**
     * 获取语音开始时间
     */
    public long getSpeechStartTime() {
        return speechStartTime;
    }
    
    /**
     * 获取语音结束时间
     */
    public long getSpeechEndTime() {
        return speechEndTime;
    }
    
    /**
     * 获取语音持续时间
     */
    public long getSpeechDuration() {
        if (speechStartTime > 0 && speechEndTime > 0) {
            return speechEndTime - speechStartTime;
        }
        return 0;
    }
    
    /**
     * 获取VAD状态信息
     */
    public String getStatusInfo() {
        StringBuilder info = new StringBuilder();
        info.append("VAD管理器状态:\n");
        info.append("- 当前VAD类型: ").append(getCurrentVadType().getDisplayName()).append("\n");
        info.append("- 是否已初始化: ").append(isInitialized()).append("\n");
        info.append("- 当前语音状态: ").append(isSpeechDetected ? "检测到语音" : "静音").append("\n");
        
        if (vadDetector != null) {
            info.append("\n").append(vadDetector.getStatusInfo());
        }
        
        return info.toString();
    }
} 